how to fully dealloc esi after working on it with an external function (x86 asm)?

[DiscoZomb1e]

Title. popping any element gives segmentation fault

[ghostinhershell]

Thanks for posting in the GitHub Community, @DiscoZomb1e!

We're happy you're here. You are more likely to get a useful response if you are posting your question in the applicable category, the New to GitHub category is solely related to conversations around getting started on using GitHub and the community for beginners of GitHub, Community on Discussions, and those new to different areas of the product alike! This question should be in the Programming Help category. I've gone ahead and moved it for you. Good luck!

[mariusCS50]

3 1 1,2,3
In assembly language, arrays are sequences of data stored in contiguous memory locations. Each element in an array occupies a fixed number of bytes, depending on its type (e.g., db for byte, dw for word, dd for double word). Accessing array elements involves calculating their memory addresses using a base address and an index, typically with scaled indexing for larger element sizes.
%include "printf32.asm"
section .data
perfect db 0b00011001
pure db 1, 0b00011001, 0b00011110, 0, 4, 5
address db 1
duplicates dd 1, 2, 3, 1, 4, 3, 16, 4, 2

msg_perfect db "The number %d is perfect", 10, 0
msg_not_perfect db "The number %d is not perfect", 10, 0
msg_pure db "The array is pure", 10, 0
msg_not_pure db "The array is not pure", 10, 0
msg_magic db "The address is magic", 10, 0
msg_not_magic db "The address is not magic", 10, 0
msg_unique db "Unique value: %d", 10, 0

section .bss
tmp0 resd 1
tmp1 resd 1

section .text
extern printf
global main
For example, to access the i-th element of a 32-bit integer array, you would multiply the index by 4 (since each dd is 4 bytes) and add it to the base address. Assembly provides no built-in array bounds checking, so managing indexes and memory safety is the programmer’s responsibility. Arrays are fundamental in assembly for handling data structures, loops, and algorithms, but require careful attention to memory alignment and addressing.
preamble:
enter 0, 0
lea eax, [tmp1]
mov [tmp0], eax
lea eax, [tmp0]
mov [address], eax
leave
ret

main:
push ebp
mov ebp, esp
call preamble

movzx eax, byte [perfect]
mov ebx, eax
shr ebx, 3
and ebx, 1
mov ecx, eax
shr ecx, 4
and ecx, 1
cmp ebx, ecx
je perfect_number
push eax
push msg_not_perfect
call printf
add esp, 8
jmp check_pure

Arrays are commonly used with loops, where a counter register is incremented to traverse through the array. However, because assembly does not include safety features like bounds checking or automatic memory management, the programmer must take care to avoid overflows or accessing invalid memory, which can lead to bugs or crashes. Despite their low-level nature, arrays in assembly are powerful and offer a high degree of control over how data is stored and manipulated, making them essential for performance-critical code, embedded systems, and operating system development.
perfect_number:
push eax
push msg_perfect
call printf
add esp, 8

check_pure:
mov esi, pure
mov ecx, 6
xor edi, edi

check_pure_loop:
mov eax, edi
test eax, eax
jz is_power_of_2
mov ebx, eax
dec ebx
and ebx, eax
jnz not_power_of_2

is_power_of_2:
movzx eax, byte [esi + edi]
mov ebx, eax
shr ebx, 3
and ebx, 1
mov edx, eax
shr edx, 4
and edx, 1
cmp ebx, edx
jne array_not_pure

not_power_of_2:
inc edi
cmp edi, ecx
jl check_pure_loop

push msg_pure
call printf
add esp, 4
jmp check_magic

array_not_pure:
push msg_not_pure
call printf
add esp, 4

check_magic:
mov eax, [address]
mov eax, [eax]
mov eax, [eax]
test eax, eax
jz address_is_magic
push msg_not_magic
call printf
add esp, 4
jmp find_unique

address_is_magic:
push msg_magic
call printf
add esp, 4

find_unique:
mov esi, duplicates
mov ecx, 9
xor eax, eax
To access an element in an array, you calculate its address by adding the base address of the array to the offset derived from the index. For instance, if each element is 4 bytes (as in a dd array), the address of the i-th element is base + i * 4. This is often done using scaled indexing like [array + esi*4] when using esi as the index register. Reading from and writing to array elements requires using the appropriate size instruction (mov, movzx, etc.), and it's the programmer's job to ensure memory is accessed correctly.
unique_loop:
xor eax, [esi]
add esi, 4
loop unique_loop

push eax
push msg_unique
call printf
add esp, 8

xor eax, eax
leave
ret

[mariusCS50]

3 3 1
When working with assembly language projects, Makefiles are incredibly useful for automating the build process. A Makefile defines rules that tell make how to compile and link files, specifying dependencies and commands. For example, if you're assembling .s or .asm files into object files using a tool like nasm or as, and then linking them with ld or gcc, you can use a Makefile to ensure everything is built in the correct order. You might write rules like program: program.o followed by a command to link the object file into an executable. This way, whenever you change your source code, you can simply run make and let it handle the rebuilding process automatically. Using Makefiles becomes especially important in larger projects, where managing dependencies by hand would be time-consuming and error-prone.
CC = gcc
CFLAGS = -m32 -fno-stack-protector -fno-PIC
LDFLAGS = -m32 -no-pie -g
BINARIES = entry
all: $(BINARIES)
entry: entry.o
$(CC) $(LDFLAGS) -Wl,-e,entry -o entry entry.o
clean:
rm -f $(BINARIES)
rm -f *~

[mariusCS50]

3 2
Functions in assembly language are building blocks for organizing code into reusable units. Unlike high-level languages where function handling is abstracted by compilers, in assembly, developers manage the calling convention manually. This typically includes saving and restoring the base pointer (ebp or rbp), pushing function arguments onto the stack, and cleaning up after the call. For instance, a function usually starts with push ebp and mov ebp, esp, and ends with leave and ret.
section .data
bitset_size dd 1000
fmt_int db "%d", 0
fmt_int_space db "%d ", 0
fmt_newline db 10, 0
input_value dd 0

section .bss
bitset resb 1000

section .text
global main
extern printf
extern scanf

insert_in_set:
push ebp
mov ebp, esp
push ebx
push ecx
push edx

mov eax, [ebp+16]
mov ebx, [ebp+8]
mov ecx, eax
shr ecx, 3
and eax, 7
mov cl, al
mov edx, 1
shl edx, cl
mov eax, [ebp+16]
shr eax, 3
or byte [ebx + eax], dl

pop edx
pop ecx
pop ebx
leave
ret

Recursion in assembly follows the same logical principle as in high-level languages: a function calls itself to break a problem into smaller subproblems. However, the implementation is far more manual and error-prone, requiring precise stack management.
read_set:
push ebp
mov ebp, esp
push ebx
push ecx
push esi

mov esi, [ebp+16]
xor ebx, ebx

read_loop:
cmp ebx, esi
jge read_done

push input_value
push fmt_int
call scanf
add esp, 8

mov eax, [input_value]
push eax
push dword [ebp+12]
push dword [ebp+8]
call insert_in_set
add esp, 12

inc ebx
jmp read_loop

read_done:
pop esi
pop ecx
pop ebx
leave
ret
Functions are essential for code clarity, reducing duplication, and supporting modular design. In x86 assembly, function arguments are passed via the stack, though some modern calling conventions (like System V AMD64) use registers. The stack frame allows each function to maintain local variables and access parameters cleanly, even if nested calls occur. When calling a function like printf, arguments are pushed in reverse order, and it is the caller's responsibility to clean the stack.
print_set:
push ebp
mov ebp, esp
push ebx
push ecx
push edx
push esi
push edi

mov ebx, [ebp+8]
mov esi, [ebp+12]
xor edi, edi

print_loop:
mov eax, edi
mov ecx, eax
shr ecx, 3
cmp ecx, esi
jae print_done

and eax, 7
mov dl, byte [ebx + ecx]
mov cl, al
shr dl, cl
and dl, 1
test dl, dl
jz next_value

push edi
push fmt_int_space
call printf
add esp, 8

next_value:
inc edi
cmp edi, 8000
jl print_loop

print_done:
push fmt_newline
call printf
add esp, 4

pop edi
pop esi
pop edx
pop ecx
pop ebx
leave
ret

When writing recursive assembly functions, every invocation must preserve the current state: registers, return address, local variables, and parameters. Failure to do so may result in corrupted stack frames or incorrect results. For example, a recursive factorial function in assembly would push the current value of n, call itself with n-1, then multiply the result upon return. It would also have to check for a base case (e.g., n == 1) and avoid excessive calls which could lead to stack overflow.
card_set:
push ebp
mov ebp, esp
push ebx
push ecx
push edx
push esi

mov ebx, [ebp+8]
mov ecx, [ebp+12]
xor eax, eax
xor esi, esi

count_loop:
cmp esi, ecx
jae count_done

mov dl, byte [ebx + esi]
push eax
movzx eax, dl
call count_bits_in_byte
pop edx
add eax, edx

inc esi
jmp count_loop

count_done:
pop esi
pop edx
pop ecx
pop ebx
leave
ret

count_bits_in_byte:
push ebp
mov ebp, esp
push ebx

mov ebx, eax
xor eax, eax

bit_count_loop:
test ebx, ebx
jz bit_count_done
mov ecx, ebx
dec ecx
and ebx, ecx
inc eax
jmp bit_count_loop

bit_count_done:
pop ebx
leave
ret

main:
push ebp
mov ebp, esp

mov edi, bitset
mov ecx, 1000
xor eax, eax
rep stosb

push 56
push dword [bitset_size]
push bitset
call insert_in_set
add esp, 12

movzx eax, byte [bitset + 7]
push eax
push fmt_int
call printf
add esp, 8
push fmt_newline
call printf
add esp, 4

push 2
push dword [bitset_size]
push bitset
call read_set
add esp, 12

movzx eax, byte [bitset + 20]
push eax
push fmt_int
call printf
add esp, 8
push fmt_newline
call printf
add esp, 4

Loops are a fundamental control structure in any language, and in assembly, they are constructed using conditional and unconditional jumps. Unlike for, while, or do-while in C or Python, in assembly, loop logic is manually built using labels and jump instructions like jmp, je, jne, jg, jl, etc.

A typical loop will involve setting up a counter, comparing it to a limit, executing some logic, updating the counter, and jumping back to the comparison step.
push dword [bitset_size]
push bitset
call print_set
add esp, 8

push dword [bitset_size]
push bitset
call card_set
add esp, 8

push eax
push fmt_int
call printf
add esp, 8
push fmt_newline
call printf
add esp, 4

xor eax, eax
leave
ret